HexDoubler is an extension to the p2a core. It increases the size of the output image by a large amount. (You of course have a choice about whether to use it on or not) When you have a small 16x16 image it can really help, for instance. Heres an example of a standard 16x16 with and without HexD, respectively. (The image is of the standard QuickTime File.)
[Note: This image was rendered without smooth edges.]
ASCII Image:
|MWMW^~^~^~^~~||_
||~~| ||~,
||__| ||_|_,
||~~| '~|~||
||__|___________|_||
||~~|^~^~^~^~^~~|~||
||__| |_||
||~~| |~||
||__| |_||
||~~| |~||
||__|___________|_||
||~~|^~^~^~^~^~~|~||
||__| |_||
||~~| |~||
||__|___________|_||
ASCII Image:
|MW^~^~^~|_
|_| |_|_
|_|_______|_|
|_| |_|
|_| |_|
|_|_______|_|
|_| |_|
|_|_______|_|
I don't feel it's perfect, but it's a nice feature. Of course, any time you can, use a bigger image at a higher resolution. They just turn out better. There are a few bugs:
READ THIS BOLD STUFF!!! REALLY!
It was not apparent in this picture, but HexD takes the last couple ASCII characters and smears them for 1/3 of the total image size. It doesn't do any damage, but you'll have to go in and trim off the extra stuff. Note slight distortion around the edges of some parts of the doubled image. However, HexD is a much better solution than actually going into a paint program and making the image twice as big (and not touching it up.) To demonstrate this, I blew up the above image (the small one) to 32x32, so that every pixel was twice as big. heres what I got, and what you'd get if you did this with *any* image in p2a.
ASCII Image:
MWMWMWMWMWMWMWMWMWMW
MWMWMW MWMW
MW MW MW MW
MWMWMW MWMWMWMW
MW MW MW MW
MWMWMWMWMWMWMWMWMWMWMWMWMW
MW MW MW MW
MWMWMW MWMWMW
MW MW MW MW
MWMWMW MWMWMW
MW MW MW MW
MWMWMWMWMWMWMWMWMWMWMWMWMW
MW MW MW MW
MWMWMW MWMWMW
MW MW MW MW
MWMWMWMWMWMWMWMWMWMWMWMWMW
Obviously it's ugly, and not what the program was intended for.
The smaller ASCII above, however, is acceptable. To show you when mr. HexD would be really helpfull, I've included a 16x16 icon converted with and without HexD. In my opinion, it does a good job making small text readable. See for yourself.
ASCII Image:
|\ '(^ |, |
|\ | | '.)
'` '^~ ' '
. . .__ . .
|.) |, \ `
| | |__ .` \
ASCII Image:
.__, .____ ., .,
|(^\ '~)(^ |(., ||
|(./ || |(^\ ||
|(^\ || || '.)|
|(./ ..)(. || ~)|
'^~` '^~^~ '` '`
., . .____ ., .,
|| | |(^^~ '\ , / `
|(..) |(., '\ `
|(^~) |(^` ./ ,
|| | |(.__ ./ ` \ ,
'` ' '^~^~ '` '`
That's all you need to know to get started.
Tech notes: ( for those who want to know a little more)
The way I was able to accomplish the size increase was to have the program scan the data more closely. Let me explain. Normally, p2a converts based on a block grid. It stores a certain amount of binary picture data in each block. It passes over each block, converting as it goes, based on what's in the block. So if most of the '1's are on the left of the block, it prints out "|" In other words, it passes over the data like this: (These are just two blocks of data, not halves of a whole graphic file.
First,
_________ _________
| | | |
| SCAN | | |
| | | |
`_________' `_________'
^ Block of data being converted into ascii fragment
Then,
_________ _________
| | | |
| | | SCAN |
| | | |
`_________' `_________'
^ Block of data being converted into ascii fragment
Etc....it moves on to the next block.
However, I realized one day that you could skip inbetween blocks, too, so that you get almost twice the resolution for the same amount of data. When you enable HexD, it scans like this:
First,
_________ _________
| | | |
| SCAN | | |
| | | |
`_________' `_________'
^ Block of data being converted into ascii fragment
Then,
_________ _________
| : | | : |
| : SC A N : |
| : | | : |
`_________' `_________'
^ Pseudo block of data being converted into ascii fragment
Then,
_________ _________
| | | |
| | | SCAN |
| | | |
`_________' `_________'
^ Block of data being converted into ascii fragment
So it converts the whole thing a half-a-block of data at a time. Not only that, but it works fairly well. It should do you good in a pinch. The only problem I saw was that it was going to be slow. But actually, it's very quick. This is partly due to the fact that p2a outputs the ascii as it figures it out. I haven't noticed any difference in speed between the two methods at all, but there probably is one. It's negligible.
